// Copyright © 2025 Alibaba Cloud. All rights reserved.
//
// Author: keria
// Date: 2025/2/19
// Brief: 沉浸式列表播放页面

import 'dart:async';
import 'dart:developer';
import 'dart:ui';

import 'package:aliplayer_widget/utils/log_util.dart';
import 'package:flutter/gestures.dart';
import 'package:flutter/material.dart';
import 'package:flutter_screenutil/flutter_screenutil.dart';
import 'package:get/get.dart';
import 'package:get/get_connect/http/src/utils/utils.dart';
import 'package:get/get_core/src/get_main.dart';
import 'package:get/get_rx/src/rx_workers/utils/debouncer.dart';
import 'package:preload_page_view/preload_page_view.dart'
    hide PageScrollPhysics;
import 'package:provider/provider.dart';
import 'package:share_plus/share_plus.dart';
import 'package:yyshort/common/apis/apis.dart';
import 'package:yyshort/common/apis/video_api.dart';
import 'package:yyshort/common/model/banner_model.dart';
import 'package:yyshort/common/model/recommend_list_model.dart';
import 'package:yyshort/common/model/useInfo_model.dart';
import 'package:yyshort/common/model/video_model.dart';
import 'package:yyshort/common/utils/alert_dialog_utils.dart';
import 'package:yyshort/common/utils/network_provider.dart';
import 'package:yyshort/common/utils/notification_service.dart';
import 'package:yyshort/common/widgets/widgets.dart';
import 'package:yyshort/pages/ali_player/constants/demo_constants.dart';
import 'package:yyshort/pages/ali_player/manager/sp_manager.dart';
import 'package:yyshort/pages/ali_player/model/video_info.dart';
import 'package:yyshort/pages/ali_player/preload/ali_player_preload.dart';
import 'package:yyshort/pages/ali_player/short_video/SharedDataController.dart';
import 'package:yyshort/pages/ali_player/short_video/short_video_item.dart';
import 'package:yyshort/pages/ali_player/short_video/short_video_item2.dart';
import 'package:yyshort/pages/ali_player/short_video/short_video_page2.dart';
import 'package:yyshort/pages/ali_player/short_video/short_video_util.dart';
import 'package:yyshort/pages/favorite_list/controller.dart';
import 'package:yyshort/pages/foryou/widgets/BottomSheetWidget.dart';
import 'package:yyshort/pages/foryou/widgets/ScrollableListWidget.dart';
import 'package:yyshort/pages/payment/controller.dart';
import 'package:yyshort/pages/payment/view.dart';
import 'package:share_plus/share_plus.dart';
import 'package:yyshort/pages/personal/personal/controller.dart';

/// 沉浸式列表播放页面
///
/// 使用 PreloadPageView 或 PageView 来实现沉浸式视频列表播放。
/// 根据 `preload` 参数决定是否启用预加载功能。
///
/// ### PreloadPageView 的优势和劣势
/// - **优势**：
///   1. **预加载支持**：`PreloadPageView` 支持页面的预加载功能，可以提前加载相邻页面的内容（如视频），从而减少用户滑动时的延迟，提升用户体验。
///   2. **流畅性**：由于预加载的存在，滑动切换页面时更加流畅，尤其是在需要加载复杂内容（如视频）的场景下。
///   3. **适合高要求场景**：对于需要快速响应和高性能的场景（如短视频应用），`PreloadPageView` 是一个更好的选择。
/// - **劣势**：
///   1. **内存占用较高**：预加载会增加内存消耗，因为需要同时加载多个页面的内容。
///   2. **依赖第三方库**：`PreloadPageView` 并不是 Flutter 官方提供的组件，而是来自第三方库，可能会引入额外的维护成本或兼容性问题。
///
/// ### PageView 的优势和劣势
/// - **优势**：
///   1. **官方支持**：`PageView` 是 Flutter 官方提供的组件，稳定性高，文档和社区支持丰富。
///   2. **轻量级**：不支持预加载，因此内存占用较低，适合对性能要求不高的场景。
///   3. **简单易用**：接口设计简洁，易于集成和使用。
/// - **劣势**：
///   1. **缺乏预加载**：`PageView` 不支持预加载功能，可能导致用户滑动时出现卡顿或延迟，尤其是在需要加载复杂内容（如视频）的场景下。
///   2. **体验较差**：在需要快速响应的场景中，`PageView` 的表现可能不如 `PreloadPageView` 流畅。
///
/// 如果你需要在性能和资源消耗之间权衡，可以根据具体需求选择合适的组件。
class ShortVideoPage2 extends StatelessWidget {
  /// 是否启用预加载功能
  ///
  /// - `true`：使用 `PreloadPageView`，支持页面预加载。
  /// - `false`：使用 `PageView`，不支持页面预加载。
  final bool preload;

  /// - `true`：数据源为videomodel类型，（剧的信息）
  /// - `false`：数据源为 epsimodel类型，（单集的信息）
  final bool isforyouPage;

  //进入页面的 数据源
  late dynamic superModel;

  ShortVideoPage2({
    super.key,
    this.preload = true, // 默认启用预加载
    this.isforyouPage = true, // 默认不是foryou
    this.superModel, // 数据源
  });

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: SafeArea(
        child: ShortVideoListPage2(
          preload: preload,
          isforyouPage: isforyouPage,
          superModel: superModel,
        ),
      ),
    );
  }
}

typedef ShortVideoCallback = void Function(dynamic result);

/// 沉浸式列表组件
// ignore: must_be_immutable
class ShortVideoListPage2 extends StatefulWidget {
  /// 是否启用预加载
  final bool preload;
  final bool isforyouPage;
  //进入页面的 数据源
  late dynamic superModel;

  ShortVideoListPage2({
    super.key,
    required this.preload,
    required this.isforyouPage,
    this.superModel, // 数据源
  });

  @override
  State<ShortVideoListPage2> createState() => ShortVideoListPageState2();
}

class ShortVideoListPageState2 extends State<ShortVideoListPage2> {
  /// 日志标签
  static const String _tag = "ShortVideoPage";

  /// 视频数据源列表（每个 item 对应一个视频）
  late List<dynamic> videoInfoList = [];

  /// 播放器预加载器
  late AliPlayerPreload _aliPlayerPreload;

  /// PageController 用于监听当前页面和预加载下一个页面
  late PageController _pageController;

  /// PreloadPageController 用于 PreloadPageView
  late PreloadPageController _preloadPageController;

  /// 当前页面索引
  int _currentIndex = 0;

  /// 存储所有 ShortVideoItem 的 GlobalKey
  final List<GlobalKey<ShortVideoItemState2>> _itemKeys = [];

  late VideoModel videoModel;

  //进入页面后，需要跳到的剧集，页面索引；
  late int willshowPage_index;

  /// 是否正在加载数据
  bool _isLoading = true;

  // ///一个全局的ValueNotifier用于通知foryou页videoModel更新。
  // // 全局通知器
  // final ValueNotifier<VideoModel?> videoModelNotifier = ValueNotifier(null);
  // 1. 初始化防抖工具（针对eventBus事件）
  final Debouncer _eventDebouncer = Debouncer(
    delay: Duration(milliseconds: 300),
  );
  @override
  void initState() {
    super.initState();

    // Get.put(FavoriteListController());
    Get.put(PersonalController());

    // 初始化预加载器
    _aliPlayerPreload = AliPlayerPreload(
      context: context,
      enableCoverUrlStrategy: true,
    );

    // 根据 preload 参数初始化控制器
    if (widget.preload) {
      _preloadPageController = PreloadPageController();
      _preloadPageController.addListener(_onPageChanged);
    } else {
      _pageController = PageController();
      _pageController.addListener(_onPageChanged);
    }

    eventBus.on<ISCanScrollEvent>().listen((event) {
      if (!widget.isforyouPage && mounted) {
        // 正确写法（先检查是否已挂载）
        // 关键：确保组件仍在 widget 树中
        setState(() {
          _allowScroll = event.isScrollAble;
          print('滑动解锁状态:$_allowScroll');
        });
      }
    });

    // eventBus.on<IsScrollUpEvent>().listen((event) {
    //   if (!widget.isforyouPage) {
    //     setState(() {
    //       _allowScroll_test = event.ScrollUp;
    //     });
    //   }
    // });

    eventBus.on<NetWorkRefreshEvent>().listen((event) {
      _loadData();
    });

    _loadData();
  }

  @override
  void dispose() {
    //关注列表刷新
    // final favoriteCTL = Get.find<FavoriteListController>();
    // if (favoriteCTL != null) {
    //   favoriteCTL.onRefresh();
    // }
    //更新用户信息
    final PersonalController temPonnalCTL = Get.find<PersonalController>();
    if (temPonnalCTL != null) {
      temPonnalCTL.onReady();
    }

    // 释放预加载器
    _aliPlayerPreload.destroy();

    // 根据 preload 参数释放控制器
    if (widget.preload) {
      _preloadPageController.dispose();
    } else {
      _pageController.dispose();
    }
    // 清理防抖器
    _pageChangeDebouncer.dispose();
    // 取消监听
    super.dispose();
  }

  /// 加载视频数据
  Future<void> _loadData() async {
    try {
      if (widget.isforyouPage) {
        // 定义监听回调
        // _videoModelListener = () {
        //   if (videoModelNotifier.value != null) {
        //     // 接收到通知，处理更新后的videoModel
        //     final updatedVideoModel = videoModelNotifier.value!;
        //     print('收到更新通知: ${updatedVideoModel.id}');

        //     // 更新列表中对应的项
        //     setState(() {
        // final index = videoInfoList.indexWhere(
        //   (item) => item.id == updatedVideoModel.id,
        // );
        // if (index != -1) {
        //   videoInfoList[index] = updatedVideoModel;
        // }
        //     });
        //   }
        // };

        // 注册监听（这里不赋值，因为addListener返回void）
        // videoModelNotifier.addListener(_videoModelListener!);

        //加载foryou 列表信息;
        final videoList = await VideoAPI.for_you_videos();

        setState(() {
          videoInfoList = videoList;
          _completeLoading();
        });
      } else {
        //短剧ID
        var video_id = '';
        late int lastWatchEpisodesId;
        if (widget.superModel is BannerModel) {
          //滚动图进入
          BannerModel model = widget.superModel as BannerModel;
          video_id = model.content!;
          // lastWatchEpisodesId = model.lastWatchEpisodesId!;
        } else if (widget.superModel is RecommendVideo) {
          //主页分栏进入
          RecommendVideo model = widget.superModel as RecommendVideo;
          video_id = model.videoId.toString();
          // lastWatchEpisodesId = model.lastWatchEpisodesId!;
        } else if (widget.superModel is VideoModel) {
          VideoModel model = widget.superModel as VideoModel;
          //区分原因：
          //其他入口进入都有lastWatchEpisodesId 字段，
          //在foryou 页面进入没有，只能使用 episodeId
          // if (model.episodeId != null) {
          //   lastWatchEpisodesId = model.episodeId!;
          // } else {
          //   lastWatchEpisodesId = model.lastWatchEpisodesId!;
          // }

          video_id = model.videoId != null
              ? model.videoId.toString()
              : model.id.toString();
        }

        //获取剧集列表
        videoModel = await VideoAPI.video_info(int.parse(video_id));
        var videoList = videoModel.episodeList;
        lastWatchEpisodesId = videoModel.lastWatchEpisodesId!;
        //判断是否需要跳到历史观看剧集 或 最大免费剧；
        willshowPage_index = videoList!.indexWhere(
          (item) => item.id == lastWatchEpisodesId,
        );

        if (willshowPage_index != -1) {
          EpisodeModel lastWatchmModel = videoList[willshowPage_index];
          if (lastWatchmModel.isUnlock != 1) {
            //未解锁，执行查找最大免费剧集，
            // 查找isUnlock == 1且索引最大的元素
            late int maxUnlockIndex;
            // ignore: unnecessary_null_comparison
            if (videoList != null && videoList.isNotEmpty) {
              for (int i = 0; i < videoList.length; i++) {
                // 当找到isUnlock == 1时，更新最大索引
                if (videoList[i].isUnlock == 1) {
                  maxUnlockIndex = i;
                }
              }
            }

            willshowPage_index = maxUnlockIndex;
          }
        }

        setState(() {
          videoInfoList = videoList.cast<dynamic>() ?? [];
          _completeLoading();
        });
      }

      // // 从本地存储中获取视频数据列表的 URL
      // final savedLink = SPManager.instance.getString(
      //   DemoConstants.keyDramaInfoListUrl,
      // );

      // if (savedLink != null) {
      //   // 加载剧集信息列表数据
      //   // final dramaInfoList = await ShortVideoUtil.loadDramaInfoList(savedLink);
      //   // // 从剧集信息列表中提取视频列表
      //   // final videoList = ShortVideoUtil.getVideoInfoListFromDramaInfo(
      //   //   dramaInfoList.firstOrNull,
      //   // );

      //   // final videoList = await VideoAPI.for_you_videos();

      //   // setState(() {
      //   //   videoInfoList = videoList;
      //   //   _completeLoading();
      //   // });
      // } else {
      //   // 加载普通视频列表数据
      //   // final videoList = await ShortVideoUtil.loadVideoInfoList(
      //   //   DemoConstants.defaultVideoInfoListUrl,
      //   // );

      //   // setState(() {
      //   //   videoInfoList = videoList;
      //   //   _completeLoading();
      //   // });
      // }
    } catch (e) {
      _handleLoadingError("Exception: $e");
    }
  }

  /// 完成加载后的公共操作
  void _completeLoading() {
    // 设置预加载器数据
    _aliPlayerPreload.setItems(videoInfoList);
    _aliPlayerPreload.moveTo(_currentIndex);

    // 动态初始化 GlobalKey
    _itemKeys.clear();
    _itemKeys.addAll(
      List.generate(
        videoInfoList.length,
        (_) => GlobalKey<ShortVideoItemState2>(),
      ),
    );

    _isLoading = false;
  }

  /// 处理加载错误
  void _handleLoadingError(String errorMessage) {
    debugPrint("[$_tag][error]: $errorMessage");
    setState(() {
      _isLoading = false;
    });
  }

  // 添加一个状态变量控制是否允许跳转到下一页
  bool _canNext = true;
  // 记录是否正在正在处理拦截，避免重复触发
  bool _isIntercepting = false;
  // ignore: prefer_typing_uninitialized_variables

  /// 页面变化监听器
  void _onPageChanged() {
    // 获取当前页面索引
    final newPageIndex = widget.preload
        ? _preloadPageController.page?.round() ?? 0
        : _pageController.page?.round() ?? 0;
    debugPrint("[$_tag]${'-' * 30}[index][$_currentIndex->$newPageIndex]");

    // double currentPage = _pageController.page!;
    // int targetPage = currentPage.round();
    // double progress = currentPage - targetPage; // 滑动进度（-0.5 ~ 0.5）
    // print("当前页面进度：$progress"); // 如 0.0（第1页）、1.2（滑向第2页）、2.0（第3页）

    // 页面离开视野（进度绝对值 > 0.5）
    // if (progress == 0.5) {
    //   setState(() {
    //     // if (_allowScroll ) {
    //     if (!widget.isforyouPage) {
    if (!widget.isforyouPage && mounted) {
      EpisodeModel tempmodel = videoInfoList[_currentIndex];
      if (tempmodel.url == null) {
        setState(() {
          _allowScroll = false;
          print('滑动解锁状态:$_allowScroll');
        });
      }
    }

    //     }

    //     // }
    //   });
    // }

    // 如果当前页面索引和新页面索引相同，则不执行任何操作
    if (_currentIndex == newPageIndex) {
      return;
    }

    // if (!widget.isforyouPage) {

    //   // if (tempmodel.isUnlock != 1) {
    //   //   // 未解锁时禁止跳转到下一页
    //   //   _canNext = false;
    //   //   return;
    //   // } else {
    //   //   // 已解锁时允许跳转到下一页
    //   //   _canNext = newPageIndex <= videoInfoList.length - 1;
    //   //   EpisodeModel nextModel = videoInfoList[newPageIndex];
    //   //   // if (nextModel.isUnlock != 1) {
    //   //   //   if (UserInfo().coin >= tempmodel.coin! && UserInfo().coin > 0) {
    //   //   //     UserInfo().coin = UserInfo().coin - tempmodel.coin!;
    //   //   //   }
    //   //   // }
    //   // }

    //   // // 检查是否是向前跳转（下一页）且不允许跳转
    //   // bool isNextPage = newPageIndex > _currentIndex;
    //   // if (isNextPage && !_canNext && !_isIntercepting) {
    //   //   _isIntercepting = true; // 标记正在处理拦截

    //   //   // 使用带动画的方式平滑回到当前页，减少闪动
    //   //   if (widget.preload && _preloadPageController.hasClients) {
    //   //     _preloadPageController
    //   //         .animateToPage(
    //   //           _currentIndex,
    //   //           duration: const Duration(milliseconds: 200), // 短动画减少视觉冲击
    //   //           curve: Curves.easeOut,
    //   //         )
    //   //         .whenComplete(() => _isIntercepting = false);
    //   //   } else if (_pageController.hasClients) {
    //   //     _pageController
    //   //         .animateToPage(
    //   //           _currentIndex,
    //   //           duration: const Duration(milliseconds: 200),
    //   //           curve: Curves.easeOut,
    //   //         )
    //   //         .whenComplete(() => _isIntercepting = false);
    //   //   }

    //   //   debugPrint(
    //   //     "[$_tag]${'-' * 30}[禁止跳转到下一页][当前页:$_currentIndex, 尝试跳转页:$newPageIndex]",
    //   //   );
    //   //   return;
    //   // }
    // }

    // 更新当前页面索引
    _currentIndex = newPageIndex;

    // 更新预加载器浮标
    _aliPlayerPreload.moveTo(newPageIndex);

    // 暂停所有后台 item
    _pauseAllExceptCurrent(newPageIndex);
    // eventBus.fire(ISCanScrollEvent(false));
  }

  /// 暂停所有后台 item
  void _pauseAllExceptCurrent(int currentIndex) {
    for (int i = 0; i < _itemKeys.length; i++) {
      if (i != currentIndex) {
        // 暂停非当前 item
        _itemKeys[i].currentState?.pause();
      } else if (i == currentIndex) {
        // 恢复当前 item
        _itemKeys[i].currentState?.resume();
      }
    }
  }

  // 提取公共的 itemBuilder 逻辑
  Widget _buildItem(BuildContext context, int index) {
    final videoItem = videoInfoList[index];
    debugPrint("[$_tag][item][lifecycle][create][${videoItem.id}]");
    return ShortVideoItem2(
      key: _itemKeys[index],
      episodeInfo: videoItem,
      videoModel: widget.isforyouPage ? null : videoModel,
      isforyouPage: widget.isforyouPage,
      //这么写自动播放的原因时因为，foryou 页面使用预加载，而解锁没有。统一设置则会冲突，或多语音，或黑屏
      autoPlay: widget.isforyouPage ? index == _currentIndex : true,

      // willMove: (nextOrLast) {
      //   _pageController
      //       .animateToPage(
      //         nextOrLast > 0 ? _currentIndex + 1 : _currentIndex - 1,
      //         duration: const Duration(milliseconds: 300),
      //         curve: Curves.linear,
      //       )
      //       .whenComplete(() => _isIntercepting = false);
      // },
      // 自动播放autoPlay: ,
      onUpdateEpisode: (EpisodeModel episode) {
        //更新数组
        final index = videoInfoList.indexWhere(
          (item) => item.sortId == episode.sortId,
        );
        if (index != -1 && episode.url!.isNotEmpty) {
          // 找到匹配项
          // 直接修改需要更新的属性（前提：EpisodeModel的这些属性是可变的）

          videoInfoList[index].isUnlock = 1; // 更新第一个参数
          videoInfoList[index].url = episode.url; // 更新第二个参数
        }
      },
      //更新点赞
      onUpdateVideoModel: (videoModel) {
        //
        videoModel.isCollect = videoModel.isCollect;
        videoModel.isLike = videoModel.isLike;
        // 发布事件
        logd('eventBus.fire----');
        eventBus.fire(VideoEvent(videoModel));
      },

      //点击解锁
      onUnlockBtnTap: (EpisodeModel model) {
        showRechargeSheet(model);
      },

      //for_you页面 才需要实现这个方法。
      watchNowTap: () {
        jumpTo_ShortVideoPage(videoItem);
        // index = videoInfoList.indexWhere((item) => item.id == tempBackModel.id);
        // if (index != -1) {
        //   print('存在相同ID，下标喂 $index');
        //   // 替换数组中对应索引位置的数据
        //   videoInfoList[index] = tempBackModel;
        // }
        // _itemKeys[index].currentState.buildPlayWidget();
      },
      //剧集列表
      onTvTap: () {
        //剧集
        List<EpisodeModel> episodeList = videoInfoList.cast<EpisodeModel>();

        //剧名
        String name = videoModel.name!;

        // 创建滚动控制器
        final ScrollController scrollController = ScrollController();

        showModalBottomSheet(
          backgroundColor: const Color(0xFF16151A), // 根据你的设计调整颜色
          context: context,
          builder: (context) => SafeArea(
            child: BottomSheetWidget(
              height: ScreenUtil().screenHeight / 4 * 3,
              secondPartText: '${'全部'.tr} ${videoInfoList.length} ${'剧集'.tr}',
              isSecondPartHidden: false,
              firstPartText: name,
              firstPartTextAlign: TextAlign.left,
              customChild: ScrollableListWidget(
                scrollController: scrollController, // 传入控制器
                playingNowIndex: _currentIndex,
                items: episodeList,
                onItemTap: (index) {
                  Navigator.pop(context); // 关键代码
                  _handleEpisodeTap(index);
                },
              ),
            ),
          ),
        ).whenComplete(() {
          // 弹窗关闭时释放控制器
          scrollController.dispose();
        });

        // 确保列表构建完成后滚动到指定位置
        WidgetsBinding.instance.addPostFrameCallback((_) {
          // 调用静态方法滚动到指定索引
          ScrollableListWidget.scrollToIndex(scrollController, _currentIndex);
        });
      },

      //分享转发
      onArrowTap: () {
        String vidStr = '';
        if (videoItem is VideoModel) {
          vidStr = videoItem.id.toString();
        } else if (videoItem is EpisodeModel) {
          vidStr = videoItem.videoId.toString();
        }
        // ignore: prefer_interpolation_to_compose_strings
        String uriString =
            'The show’s ready, no waiting around! Click the link below and bam—you’re in!😉https://yy.yyshort.com/adv/index?vid=$vidStr';
        final params = ShareParams(text: uriString);
        SharePlus.instance.share(params);
      },
    );
  }

  void jumpToCellPage(int index) {
    if (widget.preload) {
      _preloadPageController.jumpToPage(index);
    } else {
      _pageController.jumpToPage(index);
    }
  }

  // 提取：充值弹窗方法
  // 添加一个状态变量跟踪弹窗是否正在显示
  bool _isRechargeSheetShowing = false;

  // 提取：充值弹窗方法
  void showRechargeSheet(EpisodeModel model) {
    // 如果弹窗已经在显示，则直接返回，不重复弹出
    if (_isRechargeSheetShowing) {
      return;
    }

    // 标记弹窗开始显示
    _isRechargeSheetShowing = true;

    showModalBottomSheet(
          context: context,
          // 点击外部不关闭弹窗
          isDismissible: true,
          // 禁止拖动关闭（可选，根据需求决定）
          enableDrag: false,
          builder: (context) {
            return Obx(() {
              return BottomSheetWidget(
                firstPartTextAlign: TextAlign.left,
                firstPartText: '${'单价'.tr}:${model.coin}',
                isSecondPartHidden: false,
                secondPartText: '${'硬币余额'.tr}:${UserInfo().coin}',
                customChild: Container(
                  padding: const EdgeInsets.only(left: 8, top: 8, right: 8),
                  child: SafeArea(
                    child: SingleChildScrollView(
                      physics: const AlwaysScrollableScrollPhysics(),
                      child: SizedBox(
                        height:
                            ScreenUtil().screenHeight +
                            (MediaQuery.of(context).padding.bottom > 0
                                ? -64
                                : 64),
                        child: PaymentView(
                          episodeModel: model,
                          isShowInVideo: true,
                        ).buildView(),
                      ),
                    ),
                  ),
                ),
              );
            });
          },
        )
        .whenComplete(() {
          // 弹窗关闭时重置状态
          _isRechargeSheetShowing = false;
        })
        .catchError((error) {
          // 发生错误时也重置状态，避免状态异常
          _isRechargeSheetShowing = false;
          debugPrint('充值弹窗异常关闭: $error');
        });
  }

  // 点击剧集的处理逻辑入口
  void _handleEpisodeTap(int index) {
    //会员卡直接跳---积分免费需要判断=>非首集需要判断上一集是否解锁

    UserInfo userinfo = UserInfo();
    print('--------------${userinfo.vipExpireTime}');

    if (userinfo.vipExpireTime.isNotEmpty) {
      print('是会员');
      jumpToCellPage(index);
    } else {
      print('不是会员');
      if (index > 0) {
        EpisodeModel behindEpisode = videoInfoList[index - 1];
        if (behindEpisode.isUnlock != 1) {
          toastInfo(msg: '不支持跳集解锁播放'.tr);
          return;
        }
      }
      jumpToCellPage(index);
    }
  }

  // 控制滚动的开关变量
  bool _allowScroll = false;

  // bool _allowScroll_test = true;
  double? _lastVelocity;

  double _totalDragDistance = 0.0;

  // @override
  // Widget build(BuildContext context) {
  //   return Obx(() {
  //     late NetworkService networkService = Get.find<NetworkService>();
  //     if (!networkService.isApiReachable) {
  //       return Center(
  //         child: Column(
  //           mainAxisAlignment: MainAxisAlignment.center,
  //           children: [
  //             Icon(Icons.wifi_off, size: 100.w, color: Colors.grey),
  //             const SizedBox(height: 30),
  //             ElevatedButton(
  //               onPressed: () {
  //                 _loadData();
  //                 //检查网络跳转。
  //                 setState(() {
  //                   _isLoading = true;
  //                 });
  //               },
  //               style: ElevatedButton.styleFrom(
  //                 padding: const EdgeInsets.symmetric(
  //                   horizontal: 30,
  //                   vertical: 12,
  //                 ),
  //               ),
  //               child: Text('重试'.tr),
  //             ),
  //           ],
  //         ),
  //       );
  //     } else {
  //       if (_isLoading) {
  //         return Container(
  //           color: Colors.black,
  //           alignment: Alignment.center,
  //           child: const CircularProgressIndicator(),
  //         );
  //       }

  //       // 使用 WidgetsBinding 延迟执行（在渲染完成后）
  //       WidgetsBinding.instance.addPostFrameCallback((_) {
  //         // 这里的代码会在本次 build 及渲染完成后执行
  //         print("build 完成并已渲染到屏幕");
  //         if (videoInfoList.isNotEmpty) {
  //           if (!widget.isforyouPage) {
  //             if (willshowPage_index != _currentIndex) {
  //               // 跳转观看历史
  //               jumpToCellPage(willshowPage_index);
  //             }
  //           }
  //         }
  //       });

  //       // 根据 preload 参数选择使用 PreloadPageView 或 PageView
  //       return videoInfoList.isEmpty
  //           ? Center(
  //               child: Column(
  //                 mainAxisAlignment: MainAxisAlignment.center,
  //                 children: [
  //                   Icon(Icons.wifi_off, size: 100.w, color: Colors.grey),
  //                   const SizedBox(height: 30),
  //                   ElevatedButton(
  //                     onPressed: () {
  //                       _loadData();
  //                       //检查网络跳转。
  //                       setState(() {
  //                         _isLoading = true;
  //                       });
  //                     },
  //                     style: ElevatedButton.styleFrom(
  //                       padding: const EdgeInsets.symmetric(
  //                         horizontal: 30,
  //                         vertical: 12,
  //                       ),
  //                     ),
  //                     child: Text('重试'.tr),
  //                   ),
  //                 ],
  //               ),
  //             )
  //           : widget.preload
  //           ? PreloadPageView.builder(
  //               controller: _preloadPageController,
  //               scrollDirection: Axis.vertical,
  //               itemCount: videoInfoList.length,
  //               itemBuilder: _buildItem,
  //               preloadPagesCount: 1,
  //             )
  //           : GestureDetector(
  //               onVerticalDragUpdate: (details) {
  //                 // 滑动开始时重置累计距离
  //                 _totalDragDistance = 0.0;
  //                 // 记录滑动速度
  //                 _lastVelocity = details.primaryDelta;
  //               },
  //               onVerticalDragEnd: (details) {
  //                 if (details.primaryVelocity == null) return;

  //                 // 正值表示向下滑动，负值表示向上滑动
  //                 if (details.primaryVelocity! > 0) {
  //                   // print("检测到向下滑动");
  //                   // setState(() {
  //                   //   _allowScroll = true;
  //                   // });

  //                   // 手动处理滑动 - 当从禁用状态切换到启用时
  //                   if (_lastVelocity != null && _lastVelocity! > 0) {
  //                     // 计算目标页面索引
  //                     int currentIndex = _pageController.page?.toInt() ?? 0;
  //                     int targetIndex = currentIndex - 1; // 向下滑动查看上一页

  //                     // 确保目标索引有效
  //                     if (targetIndex >= 0) {
  //                       // _pageController.jumpToPage(targetIndex);
  //                       _pageController.animateToPage(
  //                         targetIndex,
  //                         duration: const Duration(milliseconds: 300),
  //                         curve: Curves.ease,
  //                       );
  //                     }
  //                   }
  //                 } else {
  //                   print("检测到向上滑动");
  //                   // 向上滑动的处理逻辑
  //                   // _allowScroll = false;
  //                 }
  //               },
  //               child: PageView.builder(
  //                 // 添加physics属性控制滚动
  //                 physics: _allowScroll
  //                     ? PageScrollPhysics() // 允许滚动（默认行为）
  //                     : NeverScrollableScrollPhysics(), // 禁止滚动
  //                 controller: _pageController,
  //                 scrollDirection: Axis.vertical,
  //                 itemCount: videoInfoList.length,
  //                 itemBuilder: _buildItem,
  //                 onPageChanged: (int index) {
  //                   print("页面切换完成，当前页面进度，当前页面索引：$index");
  //                   if (!widget.isforyouPage) {
  //                     EpisodeModel tempmodel = videoInfoList[index];
  //                     if (tempmodel.url == null) {
  //                       setState(() {
  //                         _allowScroll = false;
  //                       });
  //                     } else {
  //                       setState(() {
  //                         _allowScroll = true;
  //                       });
  //                     }
  //                   }
  //                   // 可在此处触发当前页面的初始化逻辑（如加载数据）
  //                   willshowPage_index = _currentIndex;
  //                 },
  //               ),
  //             );
  //     }
  //   });
  // }

  jumpTo_ShortVideoPage(dynamic mode) {
    Get.to(
      () => ShortVideoPage2(
        preload: false,
        isforyouPage: false,
        superModel: mode,
      ),
    );
  }

  // 定义回调函数类型

  @override
  Widget build(BuildContext context) {
    // 缩小Obx范围，只包裹网络状态检查部分
    return Obx(() {
      final NetworkService networkService = Get.find<NetworkService>();
      bool currentIsApiReachable = networkService.isApiReachable;

      // 网络不可用时的UI（最小化重建范围）
      if (!currentIsApiReachable) {
        return Center(
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: [
              Icon(Icons.wifi_off, size: 100.w, color: Colors.grey),
              const SizedBox(height: 30),
              ElevatedButton(
                onPressed: () {
                  _loadData();
                  if (mounted) {
                    setState(() => _isLoading = true);
                  }
                },
                style: ElevatedButton.styleFrom(
                  padding: const EdgeInsets.symmetric(
                    horizontal: 30,
                    vertical: 12,
                  ),
                ),
                child: Text('重试'.tr),
              ),
            ],
          ),
        );
      }

      // 网络可用时渲染主内容（脱离Obx直接返回，避免整个页面重建）
      return _buildMainContent();
    });
  }

  // 主内容构建方法（单独提取，减少重建范围）
  Widget _buildMainContent() {
    if (_isLoading) {
      return Container(
        color: Colors.black,
        alignment: Alignment.center,
        child: const CircularProgressIndicator(),
      );
    }

    // 优化addPostFrameCallback：使用标记防止重复执行
    if (!_hasHandledPostFrame) {
      WidgetsBinding.instance.addPostFrameCallback((_) {
        if (mounted && !_hasHandledPostFrame) {
          print("build 完成并已渲染到屏幕");
          if (videoInfoList.isNotEmpty && !widget.isforyouPage) {
            if (willshowPage_index != -1 &&
                willshowPage_index != _currentIndex) {
              jumpToCellPage(willshowPage_index);
            }
          }
          _hasHandledPostFrame = true; // 标记为已处理
        }
      });
    }

    if (videoInfoList.isEmpty) {
      return Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Icon(Icons.wifi_off, size: 100.w, color: Colors.grey),
            const SizedBox(height: 30),
            ElevatedButton(
              onPressed: () {
                _loadData();
                if (mounted) {
                  setState(() => _isLoading = true);
                }
              },
              style: ElevatedButton.styleFrom(
                padding: const EdgeInsets.symmetric(
                  horizontal: 30,
                  vertical: 12,
                ),
              ),
              child: Text('重试'.tr),
            ),
          ],
        ),
      );
    }

    return widget.preload ? _buildPreloadPageView() : _buildNormalPageView();
  }

  // 预加载页面视图构建
  Widget _buildPreloadPageView() {
    return PreloadPageView.builder(
      controller: _preloadPageController,
      scrollDirection: Axis.vertical,
      itemCount: videoInfoList.length,
      itemBuilder: _buildItem,
      preloadPagesCount: 1,
    );
  }

  // 需要在类中添加的成员变量
  bool _hasHandledPostFrame = false; // 标记PostFrame回调是否已处理
  final Debouncer _pageChangeDebouncer = Debouncer(
    delay: Duration(milliseconds: 200),
  ); // 页面切换防抖器

  // 普通页面视图构建（带防抖处理）
  Widget _buildNormalPageView() {
    return GestureDetector(
      onVerticalDragUpdate: (details) {
        _totalDragDistance = 0.0;
        _lastVelocity = details.primaryDelta;
      },
      onVerticalDragEnd: (details) {
        if (details.primaryVelocity == null) return;

        if (details.primaryVelocity! > 0) {
          if (_lastVelocity != null && _lastVelocity! > 0) {
            final currentIndex = _pageController.page?.toInt() ?? 0;
            final targetIndex = currentIndex - 1;
            if (targetIndex >= 0) {
              _pageController.animateToPage(
                targetIndex,
                duration: const Duration(milliseconds: 300),
                curve: Curves.ease,
              );
            }
          }
        }
      },
      child: PageView.builder(
        physics: _allowScroll
            ? PageScrollPhysics()
            : NeverScrollableScrollPhysics(),
        controller: _pageController,
        scrollDirection: Axis.vertical,
        itemCount: videoInfoList.length,
        itemBuilder: _buildItem,
        onPageChanged: (int index) {
          print("页面切换完成，当前页面索引：$index");
          if (!widget.isforyouPage) {
            // 使用防抖处理页面切换时的状态更新
            _pageChangeDebouncer.run(() {
              if (mounted) {
                final tempmodel = videoInfoList[index];
                setState(() => _allowScroll = tempmodel.url != null);
                print('滑动解锁状态:$_allowScroll');
              }
            });
          }
          willshowPage_index = _currentIndex;
        },
      ),
    );
  }
}

// 完整的防抖工具类实现
class Debouncer {
  final Duration delay;
  Timer? _timer;

  Debouncer({this.delay = const Duration(milliseconds: 200)});

  // 确保定义了run方法
  void run(VoidCallback action) {
    _timer?.cancel();
    _timer = Timer(delay, action);
  }

  void dispose() {
    _timer?.cancel();
    _timer = null;
  }
}
